feat(lang): GDScript — vendored grammar, tags.scm, gdscriptcheck.sh - #233

Summary

Adds GDScript (.gd) language support: vendored PrestonKnopp/tree-sitter-gdscript grammar,
extraction (class_name/inner classes/funcs/methods/const/enum/enum members/vars/signals + call
edges), and test/gdscriptcheck.sh.

Measured on 13 open-source Godot projects that are not in this tree — 3,525 files, 58,128 symbols,
27,768 edges, indexed cold in 0.82 s.

Before this change Godot repos were invisible: .gd fell out at crawl time as unsupported-ext, so
every ranked lens returned reason="no_candidates" — not a low-ranked answer, no candidates at all,
because the files were never parsed. --grep's unindexed-text fallback still scanned them, which made
the gap read as a ranking problem rather than a missing language. On a 224-file Godot game:
kept 0 of 40 → 9,946 symbols / 8,155 edges.

• Lang::GDScript is APPENDED after Kotlin (index 23), never inserted — the value is serialized
  into the cache. Thanks to Dart Dart: a 23rd grammar, and the span arm its tree shape requires #75's kLangCount refactor, this change moves ONE sizing constant
  instead of the nine sites it would have touched before; the refactor did exactly what it promised.
• No ingest_metrics.h or ingest_sidecap.h arm is needed, and that is measured rather than
  assumed: GDScript's function_definition carries a real body: field (so the ancestor walk finds
  it, unlike Dart's sibling function_body), and its parameters node is already counted —
  params="1" on the fixture's one-arg funcs, params="0" on the nullary ones, with
  cx/ccx/loc/nest/cbo all populated.
• Hit the same rebase collision Kotlin feat(lang): Kotlin — vendored grammar, JVM-bridged call graph #126 records, in a different constant. This branch bumped
  the gate count 616→617 for its own gate; upstream independently landed a gate and also reached 617.
  The true total is 618. Resolved the way feat(lang): Kotlin — vendored grammar, JVM-bridged call graph #126 resolved its kParserVer collision — took the number
  manifestcheck actually counts rather than either side's, since a stale count that looks checked is
  worse than none.
• Two capture choices are forced by existing gates, not taste. Enum members ride
  @definition.constant because @definition.enummember is gated by isPyEnumMemberTarget (a Python
  base-name test) and would silently drop every GDScript enumerator; member variables ride
  @definition.var because fieldCaptureKept() returns false for every language but Python and
  C/C++, so a field capture would vanish without a trace.
• Godot 4 shapes were read off real parses, not node-types.json, which mattered twice:
  @export/@onready parse as a plain variable_statement with an annotations child (the
  grammar's export_variable_statement / onready_variable_statement nodes are the Godot 3 spellings
  and never fire on modern code), and super.m() parses as attribute + attribute_call, so the
  grammar's own base_call node never fires either.

STEP 0 — parse rate, measured before any code was written

8,159 error bytes of 25.3 MB (0.032%). Five of the thirteen parse at 100%; the worst is 86.75%.
Harness built against this repo's own pinned core SHA; re-run end-to-end on a freshly re-cloned corpus
and reproduced to the byte.

STEP 6 — the blind spots, and what they actually cost

Classified by the FIRST error in each file; later errors in a degraded file are cascades. An earlier
pass over-counted match and else: if as causes until each was reproduced in isolation and parsed
clean.

1. % scene-unique-name inside a path — 23 of 33 files (70%). $%Node, %A/%B, $Path/%X fail;
   %A and $A/B alone are fine. A Godot 4 feature the grammar never learned.
2. Column-0 comment inside an indented block — ~7 files. A commented-out line between match
   branches reads as a dedent to the scanner.
3. Godot 3 keywords still reserved — 3 files. grammar.js:100-107 reserves
   remote|master|puppet|remotesync|mastersync|puppetsync, plus onready/export. Godot 4 removed
   them; remote = {} fails, o.call(remote) is fine.

All three are UPSTREAM grammar bugs. Per guardrail G3 none is patched here — no fork is carried.

Their real cost is smaller than the parse rate suggests, and that is GATED, not asserted.
tree-sitter's recovery is LOCAL: a fixture holding blind spots (1) and (3) together still yields every
definition and every call edge, losing only the erroring sub-expression. test/gdscriptcheck.sh
asserts that survival, so the arm keeps passing if a future grammar bump fixes them upstream.

NOT in this PR

Dependency edges (STEP 5). preload/load("res://…") resolution is a separate round.
dependencyCapable() and depDialectFor() are deliberately untouched — they default to false/None,
and claiming capability without edges would make the dep_files= denominator lie.
.tscn, .tres and .gdshader are not indexed.

Verification

Local state on the exact tip — clean tree, binary stamp matching HEAD:

• python3 test/pargates.py . ./build/ripwire -j 6 — 618 of 619 green. The single red,
  scroundtripcheck (B) cppqualfix: composed ids differ from the pre-change id= set, is
  PRE-EXISTING: a control run of the same suite on clean main on this machine produces
  character-identical failure text and the same single red. This branch's result is indistinguishable
  from main's.
• test/gdscriptcheck.sh written RED first — against a pre-GDScript binary it exits 1 (rc read,
  not inferred), and it is pinned in gateexitcheck's FAILFAST on that measurement. 8 arms green
  with: definition kinds, case distinction, a decoy across two files, call edges (and no edge for an
  external Godot API call), the disclosed blind spots, cold/warm determinism, crawl-root independence,
  and that .gd is no longer reported as skipped.
• Non-regression: 13 verbs byte-identical against a binary built from main, over a 3,040-file
  multi-language corpus containing zero .gd — map, metrics, clones, external-surface, callers, lint,
  for, pack-task, quality-delta, impact, uses, grep (~225 KB of output). Outputs under 500 B are
  reported INERT and not counted, so no comparison is vacuous.
• Full G1 sanitizer stack clean (-DRIPWIRE_ASAN=ON: address, undefined, integer,
  float-divide-by-zero, float-cast-overflow, -fno-sanitize-recover=all) over four corpora — the
  2,611-file external corpus (verified non-empty; the run indexed 3,525 files / 58,128 symbols), a
  224-file private game, the fixtures, and the new fuzz seed. rc=0, zero reports.
• The vendored scanner's serialize() audited for write width and classified loop1 in
  test/vendorpatchcheck.sh: structurally identical to python's (the scanner derives from it) — a
  delimiter_count clamped to UINT8_MAX then an unguarded memcpy, so the pre-loop write is at
  most 1 + 255 = 256 against a 1024-byte buffer, then a bare size < BUFFER_SIZE guard paired with a
  1-byte buffer[size++] write.
• kParserVer 96→97 with kIngestParserVerMirror; test/qschemetrip.hash and
  test/printf_parity.manifest re-pinned after reviewing every delta (help/help_all gain the
  GDScript line; lint_catalog gains ,gd on the language-agnostic naming rules; match gains
  gdscript plus the 3 new fixture files). docs/COMMANDS.md REGENERATED via
  docs/docs_commands_build.py, not hand-edited.

Size, against the two most recent language PRs

Test plan

• python3 test/pargates.py . ./build/ripwire -j 6 — 618/619, sole red pre-existing on main
  (verified by a control run of the same suite on a clean main build)
• test/gdscriptcheck.sh — 8 arms ALL PASS; exits 1 against a pre-GDScript binary
• STEP 0 parse rate over 2,938 real .gd files — 98.88%, reproduced on a freshly re-cloned corpus
• G1 sanitizer stack over 4 corpora — rc=0, zero reports, runs verified non-vacuous
• 13-verb byte-identical non-regression vs a main-built binary on a 3,040-file corpus
• Determinism (cold == warm, two runs byte-identical) and well-formed XML, in the gate

🤖 Generated with Claude Code

https://claude.ai/code/session_017WpMdz14SoD9dc5o4ic382